package tech.yqyl;

import cn.hutool.core.text.StrFormatter;
import com.vladsch.flexmark.html.HtmlRenderer;
import com.vladsch.flexmark.html2md.converter.FlexmarkHtmlConverter;
import com.vladsch.flexmark.parser.Parser;
import com.vladsch.flexmark.util.ast.Node;
import net.sourceforge.pinyin4j.PinyinHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
//import org.commonmark.node.Node;
//import org.commonmark.parser.Parser;
//import org.commonmark.renderer.html.HtmlRenderer;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @类功能说明： String字符串工具类.
 * @类修改者：
 * @修改日期：
 * @修改说明：
 * @版本：V1.0
 */
public final class StringUtil {

    private static final Log LOG = LogFactory.getLog(StringUtil.class);

    /**
     * 函数功能说明 ： 判断字符串是否为空 . 修改者名字： 修改日期： 修改内容：
     *
     * @return boolean
     * @throws
     * @参数： @param str
     * @参数： @return
     */
    public static boolean isEmpty(String str) {
        return null == str || "".equals(str) || "undefined".equals(str);
    }
    /**
     * 函数功能说明 ： 判断对象数组是否为空. 修改者名字： 修改日期： 修改内容：
     *
     * @return boolean
     * @throws
     * @参数： @param obj
     * @参数： @return
     */
    public static boolean isEmpty(Object[] obj) {
        return null == obj || 0 == obj.length;
    }

    /**
     * 函数功能说明 ： 判断对象是否为空. 修改者名字： 修改日期： 修改内容：
     *
     * @return boolean
     * @throws
     * @参数： @param obj
     * @参数： @return
     */
    public static boolean isEmpty(Object obj) {
        if (null == obj) {
            return true;
        }
        if (obj instanceof String) {
            return ((String) obj).trim().isEmpty();
        }
        return !(obj instanceof Number) ? false : false;
    }

    /**
     * 函数功能说明 ： 判断集合是否为空. 修改者名字： 修改日期： 修改内容：
     *
     * @return boolean
     * @throws
     * @参数： @param obj
     * @参数： @return
     */
    public static boolean isEmpty(List<?> obj) {
        return null == obj || obj.isEmpty();
    }

    /**
     * 函数功能说明 ： 判断Map集合是否为空. 修改者名字： 修改日期： 修改内容：
     *
     * @return boolean
     * @throws
     * @参数： @param obj
     * @参数： @return
     */
    public static boolean isEmpty(Map<?, ?> obj) {
        return null == obj || obj.isEmpty();
    }

    public static String hanZi2Pinyin(String value) {
        StringBuilder pinyin = new StringBuilder();

        for (char c : value.toCharArray()) {
            String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(c);
            if (pinyins != null) {
                pinyin.append(pinyins[0]).append(" "); // 默认取第一个拼音
            } else {
                pinyin.append(c).append(" "); // 如果没有拼音，保留原字符
            }
        }
        System.out.println(pinyin.toString().trim()); // 输出拼音
        return pinyin.toString().trim();
    }

    public static String hashString(String input) {
        try {
            // 创建 MessageDigest 实例
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            // 计算哈希值
            byte[] hashBytes = digest.digest(input.getBytes());

            // 将哈希值转换为十六进制字符串
            StringBuilder hexString = new StringBuilder();
            for (byte b : hashBytes) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }

            // 取前16个字符
            return hexString.toString().substring(0, 16);
        } catch (NoSuchAlgorithmException e) {
            return hanZi2Pinyin(input);
        }
    }

    public static List<String> extractImageUrls(String content) throws IOException {
        List<String> imageUrls = new ArrayList<>();
        // 正则表达式匹配 Markdown 图片语法
        String regex = "!\\[.*?\\]\\((.*?)\\)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            // 提取图片链接
            String imageUrl = matcher.group(1); // 获取括号中的内容
            imageUrls.add(imageUrl);
        }

        return imageUrls;
    }

    public static String html2Md(String html) {
        // 使用 jsoup 解析 HTML
        Document document = Jsoup.parse(html);
        String plainText = document.body().html();
        // 使用 flexmark 生成 Markdown
        Parser parser = Parser.builder().build();
        Node documentNode = parser.parse(plainText);
        return converter.convert(renderer.render(documentNode));
    }

    public static String md2Html(String content) {
        Node document = parser.parse(content);
        // 将节点渲染为 HTML
        return renderer.render(document);
    }

    // 手动实现一个字符串重复方法
    public static String stringRepeat(String str, int count) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < count; i++) {
            result.append(str);
        }
        return result.toString();
    }

    public static String writeMarkdown(String realPath, String content) {
        File markdownFile = new File(realPath);
        try {
            System.out.println(realPath+" created!");
            markdownFile.getParentFile().mkdirs();
            Files.write(markdownFile.toPath(), content.getBytes(StandardCharsets.UTF_8) );
        } catch (IOException e) {
        }
        return realPath;
    }

    public static boolean containsChinese(String str) {
        // 正则表达式匹配中文字符
        String regex = "[\\u4e00-\\u9fa5]";
        Pattern pattern = Pattern.compile(regex);
        return pattern.matcher(str).find();
    }


    public static List<String> find(String type, String line) {
        Pattern pattern = null;
        switch (type){
            case "title":
                pattern = patternTitle;
                break;
            case "oid":
                pattern = patternOId;
                break;
            default:
                pattern = patternTitle;
                break;
        }
        Matcher matcher = pattern.matcher(line);
        List<String> findStrs = new ArrayList<>();
        while (matcher.find()) {
            // 获取括号内的内容
            String findStr = matcher.group(1);
            // 防止出现 [fdafsa(fdss)dsa]这样的情况
            if( "title".equals(type) && line.contains(StrFormatter.format("[{}](", findStr)) ) {
                findStrs.add(findStr);
            }
            // 防止出现 dffdsa(ssfad)ssss[aaa](ssss)dfaf
            if( (!StringUtil.isEmpty(findStr)&&(findStr.endsWith(".md")||findStr.endsWith(".MD"))) && "oid".equals(type) && line.contains(StrFormatter.format("]({})", findStr)) ) {
                findStrs.add(findStr);
            }
        }
        return findStrs;
    }

    public static void generateReadme(String parentDir) {
        // 指定要查找 .md 文件的目录
//        String directoryPath = "your_directory_path"; // 修改为你的目录路径
        String outputPath = "README.md"; // 输出的 README.md 文件路径
        if( Paths.get(parentDir.concat(File.separator).concat(outputPath)).toFile().exists() ) {
            if( !YamlUtils.getConfig().getLocalStore().isOverrideReadme() ) {
                return;
            }
        }

        File directory = new File(parentDir);
        File[] files = directory.listFiles((dir, name) -> name.toLowerCase().endsWith(".md"));

        if (files != null && files.length > 0) {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(parentDir.concat(File.separator).concat(outputPath)))) {
                writer.write(StrFormatter.format("# {}\n\n", directory.getName()));

                for (File file : files) {
                    // 添加二级标题
                    String fileNameWithoutExtension = file.getName().substring(0, file.getName().lastIndexOf('.'));
                    writer.write("## [" + fileNameWithoutExtension + "](./" + file.getName() + ")\n");
                }

                System.out.println("README.md 文件已成功生成。");
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("未找到 .md 文件。");
        }
    }

    static Pattern patternTitle = Pattern.compile("\\[(.*?)\\]");
    static Pattern patternOId = Pattern.compile("\\((.*?)\\)");

    // 创建 Markdown 解析器实例
    static Parser parser = Parser.builder().build();
    // 创建 HTML 渲染器实例
    static HtmlRenderer renderer = HtmlRenderer.builder().build();
    static FlexmarkHtmlConverter converter = new FlexmarkHtmlConverter.Builder().build();
}
